var HLImport = HLImport || (function() {
    'use strict';
    var version = '0.5',
	lastUpdate = 1457920161,
	skillsAttr = ["acrobatics-ability", "acrobatics-cs", "acrobatics-ranks", "acrobatics-class", "acrobatics-ability-mod", "acrobatics-racial", "acrobatics-feat", "acrobatics-item", "acrobatics-size", "acrobatics-acp", "acrobatics-misc", "acrobatics-reqtrain", "artistry-ability", "artistry-cs", "artistry-ranks", "artistry-class", "artistry-ability-mod", "artistry-racial", "artistry-feat", "artistry-item", "artistry-size", "artistry-acp", "artistry-misc", "artistry-reqtrain", "appraise-ability", "appraise-cs", "appraise-ranks", "appraise-class", "appraise-ability-mod", "appraise-racial", "appraise-feat", "appraise-item", "appraise-size", "appraise-acp", "appraise-misc", "appraise-reqtrain", "bluff-ability", "bluff-cs", "bluff-ranks", "bluff-class", "bluff-ability-mod", "bluff-racial", "bluff-feat", "bluff-item", "bluff-size", "bluff-acp", "bluff-misc", "bluff-reqtrain", "climb-ability", "climb-cs", "climb-ranks", "climb-class", "climb-ability-mod", "climb-racial", "climb-feat", "climb-item", "climb-size", "climb-acp", "climb-misc", "climb-reqtrain", "craft-ability", "craft-cs", "craft-ranks", "craft-class", "craft-ability-mod", "craft-racial", "craft-feat", "craft-item", "craft-size", "craft-acp", "craft-misc", "craft-reqtrain", "craft2-ability", "craft2-cs", "craft2-ranks", "craft2-class", "craft2-ability-mod", "craft2-racial", "craft2-feat", "craft2-item", "craft2-size", "craft2-acp", "craft2-misc", "craft2-reqtrain", "craft3-ability", "craft3-cs", "craft3-ranks", "craft3-class", "craft3-ability-mod", "craft3-racial", "craft3-feat", "craft3-item", "craft3-size", "craft3-acp", "craft3-misc", "craft3-reqtrain", "diplomacy-ability", "diplomacy-cs", "diplomacy-ranks", "diplomacy-class", "diplomacy-ability-mod", "diplomacy-racial", "diplomacy-feat", "diplomacy-item", "diplomacy-size", "diplomacy-acp", "diplomacy-misc", "diplomacy-reqtrain", "disable-device-ability", "disable-device-cs", "disable-device-ranks", "disable-device-class", "disable-device-ability-mod", "disable-device-racial", "disable-device-feat", "disable-device-item", "disable-device-size", "disable-device-acp", "disable-device-misc", "disable-device-reqtrain", "disguise-ability", "disguise-cs", "disguise-ranks", "disguise-class", "disguise-ability-mod", "disguise-racial", "disguise-feat", "disguise-item", "disguise-size", "disguise-acp", "disguise-misc", "disguise-reqtrain", "escape-artist-ability", "escape-artist-cs", "escape-artist-ranks", "escape-artist-class", "escape-artist-ability-mod", "escape-artist-racial", "escape-artist-feat", "escape-artist-item", "escape-artist-size", "escape-artist-acp", "escape-artist-misc", "escape-artist-reqtrain", "fly-ability", "fly-cs", "fly-ranks", "fly-class", "fly-ability-mod", "fly-racial", "fly-feat", "fly-item", "fly-size", "fly-acp", "fly-misc", "fly-reqtrain", "handle-animal-ability", "handle-animal-cs", "handle-animal-ranks", "handle-animal-class", "handle-animal-ability-mod", "handle-animal-racial", "handle-animal-feat", "handle-animal-item", "handle-animal-size", "handle-animal-acp", "handle-animal-misc", "handle-animal-reqtrain", "heal-ability", "heal-cs", "heal-ranks", "heal-class", "heal-ability-mod", "heal-racial", "heal-feat", "heal-item", "heal-size", "heal-acp", "heal-misc", "heal-reqtrain", "intimidate-ability", "intimidate-cs", "intimidate-ranks", "intimidate-class", "intimidate-ability-mod", "intimidate-racial", "intimidate-feat", "intimidate-item", "intimidate-size", "intimidate-acp", "intimidate-misc", "intimidate-reqtrain", "linguistics-ability", "linguistics-cs", "linguistics-ranks", "linguistics-class", "linguistics-ability-mod", "linguistics-racial", "linguistics-feat", "linguistics-item", "linguistics-size", "linguistics-acp", "linguistics-misc", "linguistics-reqtrain", "lore-ability", "lore-cs", "lore-ranks", "lore-class", "lore-ability-mod", "lore-racial", "lore-feat", "lore-item", "lore-size", "lore-acp", "lore-misc", "lore-reqtrain", "knowledge-arcana-ability", "knowledge-arcana-cs", "knowledge-arcana-ranks", "knowledge-arcana-class", "knowledge-arcana-ability-mod", "knowledge-arcana-racial", "knowledge-arcana-feat", "knowledge-arcana-item", "knowledge-arcana-size", "knowledge-arcana-acp", "knowledge-arcana-misc", "knowledge-arcana-reqtrain", "knowledge-dungeoneering-ability", "knowledge-dungeoneering-cs", "knowledge-dungeoneering-ranks", "knowledge-dungeoneering-class", "knowledge-dungeoneering-ability-mod", "knowledge-dungeoneering-racial", "knowledge-dungeoneering-feat", "knowledge-dungeoneering-item", "knowledge-dungeoneering-size", "knowledge-dungeoneering-acp", "knowledge-dungeoneering-misc", "knowledge-dungeoneering-reqtrain", "knowledge-engineering-ability", "knowledge-engineering-cs", "knowledge-engineering-ranks", "knowledge-engineering-class", "knowledge-engineering-ability-mod", "knowledge-engineering-racial", "knowledge-engineering-feat", "knowledge-engineering-item", "knowledge-engineering-size", "knowledge-engineering-acp", "knowledge-engineering-misc", "knowledge-engineering-reqtrain", "knowledge-geography-ability", "knowledge-geography-cs", "knowledge-geography-ranks", "knowledge-geography-class", "knowledge-geography-ability-mod", "knowledge-geography-racial", "knowledge-geography-feat", "knowledge-geography-item", "knowledge-geography-size", "knowledge-geography-acp", "knowledge-geography-misc", "knowledge-geography-reqtrain", "knowledge-history-ability", "knowledge-history-cs", "knowledge-history-ranks", "knowledge-history-class", "knowledge-history-ability-mod", "knowledge-history-racial", "knowledge-history-feat", "knowledge-history-item", "knowledge-history-size", "knowledge-history-acp", "knowledge-history-misc", "knowledge-history-reqtrain", "knowledge-local-ability", "knowledge-local-cs", "knowledge-local-ranks", "knowledge-local-class", "knowledge-local-ability-mod", "knowledge-local-racial", "knowledge-local-feat", "knowledge-local-item", "knowledge-local-size", "knowledge-local-acp", "knowledge-local-misc", "knowledge-local-reqtrain", "knowledge-nature-ability", "knowledge-nature-cs", "knowledge-nature-ranks", "knowledge-nature-class", "knowledge-nature-ability-mod", "knowledge-nature-racial", "knowledge-nature-feat", "knowledge-nature-item", "knowledge-nature-size", "knowledge-nature-acp", "knowledge-nature-misc", "knowledge-nature-reqtrain", "knowledge-nobility-ability", "knowledge-nobility-cs", "knowledge-nobility-ranks", "knowledge-nobility-class", "knowledge-nobility-ability-mod", "knowledge-nobility-racial", "knowledge-nobility-feat", "knowledge-nobility-item", "knowledge-nobility-size", "knowledge-nobility-acp", "knowledge-nobility-misc", "knowledge-nobility-reqtrain", "knowledge-planes-ability", "knowledge-planes-cs", "knowledge-planes-ranks", "knowledge-planes-class", "knowledge-planes-ability-mod", "knowledge-planes-racial", "knowledge-planes-feat", "knowledge-planes-item", "knowledge-planes-size", "knowledge-planes-acp", "knowledge-planes-misc", "knowledge-planes-reqtrain", "knowledge-religion-ability", "knowledge-religion-cs", "knowledge-religion-ranks", "knowledge-religion-class", "knowledge-religion-ability-mod", "knowledge-religion-racial", "knowledge-religion-feat", "knowledge-religion-item", "knowledge-religion-size", "knowledge-religion-acp", "knowledge-religion-misc", "knowledge-religion-reqtrain", "perception-ability", "perception-cs", "perception-ranks", "perception-class", "perception-ability-mod", "perception-racial", "perception-feat", "perception-item", "perception-size", "perception-acp", "perception-misc", "perception-reqtrain", "perform-ability", "perform-cs", "perform-ranks", "perform-class", "perform-ability-mod", "perform-racial", "perform-feat", "perform-item", "perform-size", "perform-acp", "perform-misc", "perform-reqtrain", "perform2-ability", "perform2-cs", "perform2-ranks", "perform2-class", "perform2-ability-mod", "perform2-racial", "perform2-feat", "perform2-item", "perform2-size", "perform2-acp", "perform2-misc", "perform2-reqtrain", "perform3-ability", "perform3-cs", "perform3-ranks", "perform3-class", "perform3-ability-mod", "perform3-racial", "perform3-feat", "perform3-item", "perform3-size", "perform3-acp", "perform3-misc", "perform3-reqtrain", "profession-ability", "profession-cs", "profession-ranks", "profession-class", "profession-ability-mod", "profession-racial", "profession-feat", "profession-item", "profession-size", "profession-acp", "profession-misc", "profession-reqtrain", "profession2-ability", "profession2-cs", "profession2-ranks", "profession2-class", "profession2-ability-mod", "profession2-racial", "profession2-feat", "profession2-item", "profession2-size", "profession2-acp", "profession2-misc", "profession2-reqtrain", "profession3-ability", "profession3-cs", "profession3-ranks", "profession3-class", "profession3-ability-mod", "profession3-racial", "profession3-feat", "profession3-item", "profession3-size", "profession3-acp", "profession3-misc", "profession3-reqtrain", "ride-ability", "ride-cs", "ride-ranks", "ride-class", "ride-ability-mod", "ride-racial", "ride-feat", "ride-item", "ride-size", "ride-acp", "ride-misc", "ride-reqtrain", "sense-motive-ability", "sense-motive-cs", "sense-motive-ranks", "sense-motive-class", "sense-motive-ability-mod", "sense-motive-racial", "sense-motive-feat", "sense-motive-item", "sense-motive-size", "sense-motive-acp", "sense-motive-misc", "sense-motive-reqtrain", "sleight-of-hand-ability", "sleight-of-hand-cs", "sleight-of-hand-ranks", "sleight-of-hand-class", "sleight-of-hand-ability-mod", "sleight-of-hand-racial", "sleight-of-hand-feat", "sleight-of-hand-item", "sleight-of-hand-size", "sleight-of-hand-acp", "sleight-of-hand-misc", "sleight-of-hand-reqtrain", "spellcraft-ability", "spellcraft-cs", "spellcraft-ranks", "spellcraft-class", "spellcraft-ability-mod", "spellcraft-racial", "spellcraft-feat", "spellcraft-item", "spellcraft-size", "spellcraft-acp", "spellcraft-misc", "spellcraft-reqtrain", "stealth-ability",  "stealth-cs", "stealth-ranks", "stealth-class", "stealth-ability-mod", "stealth-racial", "stealth-feat", "stealth-item", "stealth-size", "stealth-acp", "stealth-misc", "stealth-reqtrain", "survival-ability", "survival-cs", "survival-ranks", "survival-class", "survival-ability-mod", "survival-racial", "survival-feat", "survival-item", "survival-size", "survival-acp", "survival-misc", "survival-reqtrain", "swim-ability", "swim-cs", "swim-ranks", "swim-class", "swim-ability-mod", "swim-racial", "swim-feat", "swim-item", "swim-size", "swim-acp", "swim-misc", "swim-reqtrain", "use-magic-device-ability", "use-magic-device-cs", "use-magic-device-ranks", "use-magic-device-class", "use-magic-device-ability-mod", "use-magic-device-racial", "use-magic-device-feat", "use-magic-device-item", "use-magic-device-size", "use-magic-device-acp", "use-magic-device-misc", "use-magic-device-reqtrain", "misc-skill-0-ability", "misc-skill-0-cs", "misc-skill-0-ranks", "misc-skill-0-class", "misc-skill-0-ability-mod", "misc-skill-0-racial", "misc-skill-0-feat", "misc-skill-0-item", "misc-skill-0-size", "misc-skill-0-acp", "misc-skill-0-misc", "misc-skill-0-reqtrain", "misc-skill-1-ability", "misc-skill-1-cs", "misc-skill-1-ranks", "misc-skill-1-class", "misc-skill-1-ability-mod", "misc-skill-1-racial", "misc-skill-1-feat", "misc-skill-1-item", "misc-skill-1-size", "misc-skill-1-acp", "misc-skill-1-misc", "misc-skill-1-reqtrain", "misc-skill-2-ability", "misc-skill-2-cs", "misc-skill-2-ranks", "misc-skill-2-class", "misc-skill-2-ability-mod", "misc-skill-2-racial", "misc-skill-2-feat", "misc-skill-2-item", "misc-skill-2-size", "misc-skill-2-acp", "misc-skill-2-misc", "misc-skill-2-reqtrain", "misc-skill-3-ability", "misc-skill-3-cs", "misc-skill-3-ranks", "misc-skill-3-class", "misc-skill-3-ability-mod", "misc-skill-3-racial", "misc-skill-3-feat", "misc-skill-3-item", "misc-skill-3-size", "misc-skill-3-acp", "misc-skill-3-misc", "misc-skill-3-reqtrain", "misc-skill-4-ability", "misc-skill-4-cs", "misc-skill-4-ranks", "misc-skill-4-class", "misc-skill-4-ability-mod", "misc-skill-4-racial", "misc-skill-4-feat", "misc-skill-4-item", "misc-skill-4-size", "misc-skill-4-acp", "misc-skill-4-misc", "misc-skill-4-reqtrain", "misc-skill-5-ability", "misc-skill-5-cs", "misc-skill-5-ranks", "misc-skill-5-class", "misc-skill-5-ability-mod", "misc-skill-5-racial", "misc-skill-5-feat", "misc-skill-5-item", "misc-skill-5-size", "misc-skill-5-acp", "misc-skill-5-misc", "misc-skill-5-reqtrain", "craft-name", "craft2-name", "craft3-name", "lore-name", "perform-name", "perform2-name", "perform3-name", "profession-name", "profession2-name", "profession3-name", "misc-skill-0-name", "misc-skill-1-name", "misc-skill-2-name", "misc-skill-3-name", "misc-skill-4-name", "misc-skill-5-name", "acrobatics-macro", "artistry-macro", "appraise-macro", "bluff-macro", "climb-macro", "craft-macro", "craft2-macro", "craft3-macro", "diplomacy-macro", "disable-Device-macro", "disguise-macro", "escape-Artist-macro", "fly-macro", "handle-Animal-macro", "heal-macro", "intimidate-macro", "linguistics-macro", "lore-macro", "knowledge-arcana-macro", "knowledge-dungeoneering-macro", "knowledge-engineering-macro", "knowledge-geography-macro", "knowledge-history-macro", "knowledge-local-macro", "knowledge-nature-macro", "knowledge-nobility-macro", "knowledge-planes-macro", "knowledge-religion-macro", "perception-macro", "perform-macro", "perform2-macro", "perform3-macro", "profession-macro", "profession2-macro", "profession3-macro", "ride-macro", "sense-Motive-macro", "sleight-of-Hand-macro", "spellcraft-macro", "stealth-macro", "survival-macro", "swim-macro", "use-magic-device-macro", "misc-skill-0-macro", "misc-skill-1-macro", "misc-skill-2-macro", "misc-skill-3-macro", "misc-skill-4-macro", "misc-skill-5-macro"],

	regexIndexOf = function(str, regex, startpos) {
		var indexOf = str.substring(startpos || 0).search(regex);
		return (indexOf >= 0) ? (indexOf + (startpos || 0)) : indexOf;
	},

	generateUUID = (function() {
		var a = 0, b = [];
		return function() {
			var c = (new Date()).getTime() + 0, d = c === a;
			a = c;
			for (var e = new Array(8), f = 7; 0 <= f; f--) {
				e[f] = "-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz".charAt(c % 64);
				c = Math.floor(c / 64);
			}
			c = e.join("");
			if (d) {
				for (f = 11; 0 <= f && 63 === b[f]; f--) {
					b[f] = 0;
				}
				b[f]++;
			} else {
				for (f = 0; 12 > f; f++) {
					b[f] = Math.floor(64 * Math.random());
				}
			}
			for (f = 0; 12 > f; f++){
				c += "-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz".charAt(b[f]);
			}
			return c;
		};
	}()),

	generateRowID = function () {
		"use strict";
		return generateUUID().replace(/_/g, "Z");
	},

	buildNameList = function (objArray)
	{
		var list = "";
		var i = 1;
		if (objArray.length > 0)
			list = objArray[0]._name;
		else
			return "";
		while (i < objArray.length)
		{
			list += ", " + objArray[i]._name;
			i++;
		}
		return list;
	},

	buildShortNameList = function (objArray)
	{
		var list = "";
		var i = 1;
		if (objArray.length > 0)
			list = objArray[0]._shortname;
		else
			return "";
		while (i < objArray.length)
		{
			list += ", " + objArray[i]._shortname;
			i++;
		}
		return list;
	},

	setAttr = function (character,attribute,value)
	{
		var attrObjs = findObjs({ _type: "attribute", _characterid: character.get("_id"), name: attribute });
		
		if (attrObjs.length > 0)
			attrObjs[0].set("current",value);
		else
			createObj("attribute", { name: attribute, _characterid: character.get("_id"), current: value });
	},

	parseNum = function (num)
	{
		if (_.isUndefined(num) || num === "")
			return 0;
		return parseInt(num);
	},

	importSaves = function (character,saves)
	{
		// Since the XML doesn't break this down by class, add it all to class 0
		var i = 0;
		var saveNotes = saves.allsaves.situationalmodifiers._text;
		for (i = 0; i < saves.save.length; i++)
		{
			var save = saves.save[i];
			var abbr = save._abbr;
			
			setAttr(character,"class-0-"+abbr,parseNum(save._base));
			setAttr(character,abbr+"-resist",parseNum(save._fromresist));
			setAttr(character,abbr+"-misc",(parseNum(save._save)-parseNum(save._base)-parseNum(save._fromresist)-parseNum(save._fromattr)));
			
			if (save.situationalmodifiers._text !== "" && saveNotes.indexOf(save.situationalmodifiers._text) === -1)
				saveNotes = saveNotes + "\n**"+abbr+":** " + save.situationalmodifiers._text;
				
		}
		setAttr(character,"Save-notes",saveNotes.trim());
	},

	importAbilityScores = function (character,attributes)
	{
		attributes.forEach(function(abScore) {
			var abName = abScore._name.substr(0,3).toUpperCase();
			var base = parseNum(abScore.attrvalue._base);
			var modifier = parseNum(abScore.attrvalue._modified) - base;  // Modifier is the total difference between what HL is reporting as the character's base ability score and the final modified ability score
			setAttr(character, abName+"-base", base);
			// If the modifier is positive, assume it's an enhancement bonus; otherwise, assume it's a penalty
			if (modifier > 0)
				setAttr(character, abName+"-enhance", modifier);
			else
				setAttr(character, abName+"-penalty", modifier);
		});
	},

	importClasses = function (character, classes)
	{
		var classList = new Object();
		
		var i = 0;
		var classObj;
		while (i < classes.length)
		{
			classObj = classes[i];

			// We can only handle 5 classes
			if (i >= 5)
				return;
			classList[classObj._name.replace(/\(([^\)]+)\)/g,"").replace("(","").replace(")","").trim()] = classObj;
			setAttr(character,"class-"+i+"-name",classObj._name);
			setAttr(character,"class-"+i+"-level",classObj._level);
			
			i++;
		}

		return classList;
	},

	getSizeMod = function (size)
	{
		switch(size.toLowerCase())
		{
			case "colossal":
				return -8;
				break;
			case "gargantuan":
				return -4;
				break
			case "huge":
				return -2;
				break;
			case "large":
				return -1;
				break;
			case "small":
				return 1;
				break;
			case "tiny":
				return 2;
				break;
			case "diminutive":
				return 4;
				break;
			case "fine":
				return 8;
				break;
			default:
				return 0;
		}
	},
	
	importInit = function(character,initObj)
	{
		setAttr(character,"init-misc",parseNum(initObj._total)-parseNum(initObj._attrtext));
		setAttr(character,"init-ability","@{"+initObj._attrname.substr(0,3).toUpperCase()+"-mod}");
		setAttr(character,"init_notes",initObj.situationalmodifiers._text);
	},

	// Calculate number of bonus slots from spell level and ability modifier
	bonusSpellSlots = function(abilMod,spellLevel) { return Math.floor((abilMod + 4 - spellLevel) / 4); },

	// Find an existing repeatable item with the same name, or generate new row ID
	getOrMakeRowID = function(character,repeatPrefix,name)
	{
		// Get list of all of the character's attributes
		var attrObjs = findObjs({ _type: "attribute", _characterid: character.get("_id") });
		
		var i = 0;
		while (i < attrObjs.length)
		{
			// If this is a feat taken multiple times, strip the number of times it was taken from the name
			var attrName = attrObjs[i].get("current").toString();
			if (regexIndexOf(attrName, / x[0-9]+$/) !== -1)
				attrName = attrName.replace(/ x[0-9]+/,"");

			if (attrObjs[i].get("name").indexOf(repeatPrefix) !== -1 && attrObjs[i].get("name").indexOf("_name") !== -1 && attrName === name)
				return attrObjs[i].get("name").substring(repeatPrefix.length,(attrObjs[i].get("name").indexOf("_name")));
			i++;
		}
		return generateRowID();
	},
	
	// Find an existing repeatable item with the same name and spellclass, or generate new row ID
	getOrMakeSpellRowID = function(character,repeatPrefix,name,spellclass)
	{
		// Get list of all of the character's attributes
		var attrObjs = findObjs({ _type: "attribute", _characterid: character.get("_id") });
		var ID;
		
		var i = 0;
		while (i < attrObjs.length)
		{
			// If this is a feat taken multiple times, strip the number of times it was taken from the name
			var attrName = attrObjs[i].get("current").toString();
			if (regexIndexOf(attrName, / x[0-9]+$/) !== -1)
				attrName = attrName.replace(/ x[0-9]+/,"");

			if (attrObjs[i].get("name").indexOf(repeatPrefix) !== -1 && attrObjs[i].get("name").indexOf("_name") !== -1 && attrName === name)
			{
				ID = attrObjs[i].get("name").substring(repeatPrefix.length,(attrObjs[i].get("name").indexOf("_name")));
				if (getAttrByName(character.get("_id"),repeatPrefix+ID+"_spellclass") === spellclass)
					return ID;
			}
			i++;
		}
		return generateRowID();
	},

	importFeats = function(character,feats)
	{
		feats.forEach(function(feat)
		{
			// Count the number of times the feat is listed, so we can indicate that in the feat name
			var i = 0;
			var taken = 0;
			while (i < feats.length)
			{
				if (feats[i]._name === feat._name)
					taken++;
				i++;
			}
			var row = getOrMakeRowID(character,"repeating_feat_",feat._name);
			if (taken > 1)
				setAttr(character,"repeating_feat_"+row+"_name",feat._name + " x" + taken);
			else
				setAttr(character,"repeating_feat_"+row+"_name",feat._name);
			setAttr(character,"repeating_feat_"+row+"_description",feat.description);
		});
	},

	importTraits = function(character,traits)
	{
		traits.forEach(function(trait)
		{
			var row = getOrMakeRowID(character,"repeating_trait_",trait._name);
			setAttr(character,"repeating_trait_"+row+"_name",trait._name);
			setAttr(character,"repeating_trait_"+row+"_description",trait.description);
		});
	},
	
	clearSkills = function(character)
	{
		// Get list of all of the character's attributes
		var attrObjs = findObjs({ _type: "attribute", _characterid: character.get("_id") });
		
		attrObjs.forEach(function(attr) {
			if (_.contains(skillsAttr,attr.get("name").toLowerCase()))
				attr.remove();
		});
	},
	
	safeAttrValue = function(attr)
	{
		if (attr == "undefined")
			return "";
		else
			return attr;
	},
	
	importSkills = function(character,skills,size,ACP)
	{
		// Ripped from the PF character sheet JS
		var skillSize;
		switch (Math.abs(size)){
			case 0: skillSize=0;break;
			case 1: skillSize=2;break;
			case 2: skillSize=4;break;
			case 4: skillSize=6;break;
			case 8: skillSize=8;break;
			case 16: skillSize=10;break;
			default: skillSize=0;
		}
		if(size<0) {skillSize=skillSize*-1;}

		// Clear out all existing skills data
		clearSkills(character);
		
		// Keep track of which of these skills we're on
		var craft = 1;
		var perform = 1;
		var profession = 1;
		var artistry = 1;
		var lore = 1;
		var misc = 0;
		
		var i = 0;
		var skill;
		var skillMisc;
		var skillAttrPrefix;
		for (i = 0; i < skills.length; i++)
		{
			skill = skills[i];
			
			// Figure out where we're putting this skill on the character sheet
			if (skill._name.indexOf("Craft") !== -1)
			{
				if (craft === 1)
				{
					skillAttrPrefix = "craft";
					setAttr(character,"craft-name",skill._name.match(/\(([^\)]+)\)/)[0].replace("(","").replace(")",""));
					craft++;
				}
				else if (craft <= 3)
				{
					skillAttrPrefix = "craft" + craft;
					setAttr(character,"craft"+craft+"-name",skill._name.match(/\(([^\)]+)\)/)[0].replace("(","").replace(")",""));
					craft++;
				}
				else
				{
					if (misc <= 5)
					{
						skillAttrPrefix = "misc-skill-" + misc;
						setAttr(character,skillAttrPrefix+"-name",skill._name);
						misc++;
					}
					else
						log("Ran out of misc skills for " + skill._name + "!");
				}
			}
			else if (skill._name.indexOf("Perform") !== -1)
			{
				if (perform === 1)
				{
					skillAttrPrefix = "perform";
					setAttr(character,"perform-name",skill._name.match(/\(([^\)]+)\)/)[0].replace("(","").replace(")",""));
					perform++;
				}
				else if (perform <= 3)
				{
					skillAttrPrefix = "perform" + perform;
					setAttr(character,"perform"+perform+"-name",skill._name.match(/\(([^\)]+)\)/)[0].replace("(","").replace(")",""));
					perform++;
				}
				else
				{
					if (misc <= 5)
					{
						skillAttrPrefix = "misc-skill-" + misc;
						setAttr(character,skillAttrPrefix+"-name",skill._name);
						misc++;
					}
					else
						log("Ran out of misc skills for " + skill._name + "!");
				}
			}
			else if (skill._name.indexOf("Profession") !== -1)
			{
				if (profession === 1)
				{
					skillAttrPrefix = "profession";
					setAttr(character,"profession-name",skill._name.match(/\(([^\)]+)\)/)[0].replace("(","").replace(")",""));
					profession++;
				}
				else if (profession <= 3)
				{
					skillAttrPrefix = "profession" + profession;
					setAttr(character,"profession"+profession+"-name",skill._name.match(/\(([^\)]+)\)/)[0].replace("(","").replace(")",""));
					profession++;
				}
				else
				{
					if (misc <= 5)
					{
						skillAttrPrefix = "misc-skill-" + misc;
						setAttr(character,skillAttrPrefix+"-name",skill._name);
						misc++;
					}
					else
						log("Ran out of misc skills for " + skill._name + "!");
				}
			}
			else if (skill._name.indexOf("Knowledge") !== -1)
			{
				switch(skill._name.match(/\(([^\)]+)\)/g)[0])
				{
					case "(arcana)":
					case "(dungeoneering)":
					case "(engineering)":
					case "(geography)":
					case "(history)":
					case "(local)":
					case "(nature)":
					case "(nobility)":
					case "(planes)":
					case "(religion)":
						skillAttrPrefix = skill._name.toLowerCase().replace(/\s/g,"-").replace("(","").replace(")","");
						break;
					default:
						skillAttrPrefix = "misc-skill-" + misc;
						setAttr(character,skillAttrPrefix+"-name",skill._name);
						misc++;
				}
			}
			else if (skill._name.indexOf("Artistry") !== -1)
			{
				if (artistry === 1)
				{
					skillAttrPrefix = "artistry";
					artistry++;
				}
				else
				{
					if (misc <= 5)
					{
						skillAttrPrefix = "misc-skill-" + misc;
						setAttr(character,skillAttrPrefix+"-name",skill._name);
						misc++;
					}
					else
						log("Ran out of misc skills for " + skill._name + "!");
				}
			}
			else if (skill._name.indexOf("Lore") !== -1)
			{
				if (lore === 1)
				{
					skillAttrPrefix = "lore";
					setAttr(character,"lore-name",skill._name.match(/\(([^\)]+)\)/)[0].replace("(","").replace(")",""));
					lore++;
				}
				else
				{
					if (misc <= 5)
					{
						skillAttrPrefix = "misc-skill-" + misc;
						setAttr(character,skillAttrPrefix+"-name",skill._name);
						misc++;
					}
					else
						log("Ran out of misc skills for " + skill._name + "!");
				}
			}
			else
				skillAttrPrefix = skill._name.toLowerCase().replace(/\s/g,"-").replace("(","").replace(")","").replace("-hand","-Hand").replace("e-device","e-Device").replace("-artist","-Artist").replace("-animal","-Animal");
			
			setAttr(character,skillAttrPrefix+"-ranks",parseNum(skill._ranks));
			setAttr(character,skillAttrPrefix+"-ability","@{"+skill._attrname+"-mod}");
			
			if (skill._classskill === "yes") setAttr(character,skillAttrPrefix+"-cs",3);
			
			skillMisc = parseNum(skill._value) - parseNum(skill._ranks)- parseNum(skill._attrbonus);
			if (parseNum(skill._ranks) != 0 && skill._classskill === "yes")
				skillMisc -= 3;
			if (skill._armorcheck === "yes")
				skillMisc -= ACP;
			if (skill._name === "Fly")
				skillMisc -= skillSize;
			if (skill._name === "Stealth")
				skillMisc -= (2 * skillSize);
			setAttr(character,skillAttrPrefix+"-misc",skillMisc);
			
			if (skill._trainedonly === "yes") setAttr(character,skillAttrPrefix+"-ReqTrain",1);
		
			// Add situation modifiers to the macro
			if (!_.isUndefined(skill.situationalmodifiers.situationalmodifier))
			{
				var macro = "@{PC-whisper} &{template:pf_generic} {{header_image=@{header_image-pf_generic}}} {{character_name=@{character_name}}} {{character_id=@{character_id}}} {{subtitle}} {{name="+skill._name+"}} {{Check=[[ 1d20 + [[ @{"+skillAttrPrefix+"} ]] ]]}}";
				skill.situationalmodifiers.situationalmodifier = arrayify(skill.situationalmodifiers.situationalmodifier);
				var j = 0;
				while (j < skill.situationalmodifiers.situationalmodifier.length)
				{
					macro = macro + " {{" + skill.situationalmodifiers.situationalmodifier[j]._source + "=" + skill.situationalmodifiers.situationalmodifier[j]._text+"}}"
					j++;
				}
				setAttr(character,skillAttrPrefix+"-macro",macro);
			}
		}
	},
	
	// Import ACP and Max Dex; these aren't included under items, but the final values are listed in penalties
	importPenalties = function (character,penalties)
	{
		var ACP = 0;
		var i = 0;
		while (i < penalties.length)
		{
			if (penalties[i]._name === "Armor Check Penalty")
			{
				ACP = parseNum(penalties[i]._value);
				setAttr(character,"armor3-acp",ACP);
			}
			else if (penalties[i]._name === "Max Dex Bonus")
				setAttr(character,"armor3-max-dex",Math.min(99, parseNum(penalties[i]._value)));	// Hero Lab uses 1000 for Max Dex when player doesn't have one; cap it at 99 to match sheet default
			i++;
		}
		return ACP;
	},
	
	// Make sure "stuff" is an array
	arrayify = function(stuff)
	{
		if (_.isUndefined(stuff))
			return new Array();
		if (Array.isArray(stuff))
			return stuff;
		return new Array(stuff);
	},

	// Import spellclasses; presence in spellclasses node means it's a spellcaster, but some of the data is in the classes node
	importSpellClasses = function (character,spellclasses,classes,abScores)
	{
		var spellClassesList = new Object();

		var i, j, abMod = 0, currentAbMod, spellslots, spelllevel, casterlevel, concmod, spellpenmod;
		var spellClassIndex = 0;
		for (i = 0; i < spellclasses.length; i++)
		{
			var spellClass = spellclasses[i];
			// Only 3 spellclasses on character sheet, so if they somehow have more...
			if (spellClassIndex >= 3)
				return spellClassesList;

			var spellClassName = spellClass._name.replace(/\(([^\)]+)\)/g,"").replace("(","").replace(")","").trim();
			var classIndex = _.indexOf(Object.keys(classes),spellClassName);
			if (classIndex !== -1)
			{
				casterlevel = parseNum(classes[spellClassName]._casterlevel);
				setAttr(character,"spellclass-"+spellClassIndex,classIndex);
				setAttr(character,"spellclass-"+spellClassIndex+"-level-misc", casterlevel - parseNum(classes[spellClassName]._level));
				
				if (!_.isUndefined(classes[spellClassName].arcanespellfailure))
					setAttr(character,"armor3-spell-fail",parseNum(classes[spellClassName].arcanespellfailure._value));
					
				// Make a guess at which ability modifier is used for this class... unless it's already been set
				currentAbMod = getAttrByName(character.get("_id"),"Concentration-"+spellClassIndex+"-ability");
				if (!_.isUndefined(classes[spellClassName]._basespelldc))
					abMod = parseNum(classes[spellClassName]._basespelldc) - 10;
				if ((currentAbMod === "" || currentAbMod === "0") && !_.isUndefined(classes[spellClassName]._basespelldc))
				{
					// Start at the fourth ability score (Intelligence), so we skill the physical abilities
					log(abScores.length);
					for (j = 3; j < abScores.length; j++)
					{
						log (abMod+" vs "+parseNum(abScores[j].attrbonus._modified));
						if (parseNum(abScores[j].attrbonus._modified) === abMod)
						{
							log("Guess found, setting to " + abScores[j]._name);
							setAttr(character,"Concentration-"+spellClassIndex+"-ability","(@{"+abScores[j]._name.substr(0,3).toUpperCase()+"-mod})");
							break;
						}
					}
				}
				if (abMod !== 0)
				{
					// Calculate misc mods to concentration
					if (!_.isUndefined(classes[spellClassName]._concentrationcheck))
					{
						concmod = parseNum(classes[spellClassName]._concentrationcheck) - casterlevel - abMod;
						setAttr(character,"Concentration-"+spellClassIndex+"-misc",concmod);
					}

					// Calculate misc mods to spell penetration
					if (!_.isUndefined(classes[spellClassName].overcomespellresistance))
					{
						spellpenmod = parseNum(classes[spellClassName].overcomespellresistance) - casterlevel;
						setAttr(character,"spellclass-"+spellClassIndex+"-SP_misc",spellpenmod);
					}

					// Populate spells / day; Hero Lab includes bonus slots, so remove those
					if (!_.isUndefined(spellclasses[i].spelllevel))
					{
						spellclasses[i].spelllevel = arrayify(spellclasses[i].spelllevel);
						for (j = 0; j < spellclasses[i].spelllevel.length; j++)
						{
							spellslots = parseNum(spellclasses[i].spelllevel[j]._maxcasts);
							spelllevel = parseNum(spellclasses[i].spelllevel[j]._level);
							if (spelllevel > 0)
								spellslots = spellslots - bonusSpellSlots(abMod,spelllevel);
							setAttr(character,"spellclass-"+spellClassIndex+"-level-"+spelllevel+"-class",spellslots);
						}
					}
				}
				spellClassesList[spellClassName] = classes[spellClassName];
				spellClassIndex++;
			}
		}
		
		return spellClassesList;
	},
	
	importSpells = function(character,spells,spellclasses)
	{
		var i, rowID, repeatPrefix, spellClass, spellName, school, level;
		var spellClassesKeys = Object.keys(spellclasses);
		for (i = 0; i < spells.length; i++)
		{
			// Search for a repeating spell with the same level, name, and spellclass; if not found, make new row
			level = parseNum(spells[i]._level);
			repeatPrefix = "repeating_lvl-"+level+"-spells_";
			spellClass = "@{spellclass-"+_.indexOf(spellClassesKeys,spells[i]._class)+"-name}";
			spellName = spells[i]._name.replace(/\(x\d+\)/,"").trim();
			rowID = getOrMakeSpellRowID(character,repeatPrefix,spellName,spellClass);
			// Update prefix with ID
			repeatPrefix = repeatPrefix + rowID;
			
			setAttr(character,repeatPrefix+"_name",spellName);
			setAttr(character,repeatPrefix+"_spellclass",spellClass);
			setAttr(character,repeatPrefix+"_components",spells[i]._componenttext.replace("Divine Focus", "DF").replace("Focus","F").replace("Material","M").replace("Verbal","V").replace("Somatic","S").replace(" or ","/"));
			setAttr(character,repeatPrefix+"_range",spells[i]._range);
			setAttr(character,repeatPrefix+"_duration",spells[i]._duration);
			setAttr(character,repeatPrefix+"_save",spells[i]._save.replace(/DC \d+/,"").trim());
			setAttr(character,repeatPrefix+"_cast-time",spells[i]._casttime);
			setAttr(character,repeatPrefix+"_sr",spells[i]._resist.replace("harmless","Harmless"));
			setAttr(character,repeatPrefix+"_DC_misc",parseNum(spells[i]._dc) - parseNum(spellclasses[spells[i]._class]._basespelldc) - level);

			if (spells[i]._area !== "")
				setAttr(character,repeatPrefix+"_targets",spells[i]._area);
			else if (spells[i]._effect !== "")
				setAttr(character,repeatPrefix+"_targets",spells[i]._effect);
			else
				setAttr(character,repeatPrefix+"_targets",spells[i]._target);
			
			school = spells[i]._schooltext;
			if (spells[i]._subschooltext !== "")
				school = school + " (" + spells[i]._subschooltext + ")";
			if (spells[i]._descriptortext !== "")
				school = school + " [" + spells[i]._descriptortext + "]";
			setAttr(character,repeatPrefix+"_school",school);
			
			setAttr(character,repeatPrefix+"_description",spells[i].description);
		}
	},
	
	calcHitDice = function (hitdice)
	{
		var dice = hitdice.match(/\d+d\d/g);
		var numDice = 0;
		var i = 0;
		while (i < dice.length)
		{
			numDice += parseInt(dice[i].split("d")[0]);
			i++;
		}
		return numDice;
	},

	importCharacter = function (characterObj,token)
	{
		var R20character = findObjs({ _type: "character", name: characterObj._name });
		if (R20character.length === 0)
			R20character = createObj("character", { name: characterObj._name });
		else
			R20character = R20character[0];

		importAbilityScores(R20character,characterObj.attributes.attribute);
		importSaves(R20character,characterObj.saves);

		var classes;
		var spellClasses;
		if (!_.isUndefined(characterObj.classes.class))
		{
			// Class will be an array if multiclassed, but a single object if single-classed; make it an array, just to be safe
			characterObj.classes.class = arrayify(characterObj.classes.class);
			classes = importClasses(R20character,characterObj.classes.class);
			characterObj.spellclasses.spellclass = arrayify(characterObj.spellclasses.spellclass);
			spellClasses = importSpellClasses(R20character,characterObj.spellclasses.spellclass,classes,characterObj.attributes.attribute);
			if (!_.isUndefined(characterObj.spellsknown.spell))
			{
				characterObj.spellsknown.spell = arrayify(characterObj.spellsknown.spell);
				importSpells(R20character,characterObj.spellsknown.spell,spellClasses);
			}
			if (!_.isUndefined(characterObj.spellsmemorized.spell))
			{
				characterObj.spellsmemorized.spell = arrayify(characterObj.spellsmemorized.spell);
				importSpells(R20character,characterObj.spellsmemorized.spell,spellClasses);
			}
			if (!_.isUndefined(characterObj.spellbook.spell))
			{
				characterObj.spellbook.spell = arrayify(characterObj.spellbook.spell);
				importSpells(R20character,characterObj.spellbook.spell,spellClasses);
			}
		}
		

		setAttr(R20character,"class-0-bab",parseNum(characterObj.attack._baseattack));
		
		if (!_.isUndefined(characterObj.feats.feat))
		{
			characterObj.feats.feat = arrayify(characterObj.feats.feat);
			importFeats(R20character,characterObj.feats.feat);
		}
		if (!_.isUndefined(characterObj.traits.trait))
		{
			characterObj.traits.trait = arrayify(characterObj.traits.trait);
			importTraits(R20character,characterObj.traits.trait);
		}
		
		// Set max hp; remove hp from Con mod first, since the sheet will add that in
		// Since the XML doesn't break this down by class, add it all to class 0
		var level = calcHitDice(characterObj.health._hitdice);
		setAttr(R20character,"class-0-hp",(parseNum(characterObj.health._hitpoints) - (level * parseNum(characterObj.attributes.attribute[2].attrbonus._modified))));
		importInit(R20character,characterObj.initiative);
		var racialHD = level - parseNum(characterObj.classes._level);
		if (racialHD > 0)
			setAttr(R20character,"class-5-level",racialHD);

		var size = getSizeMod(characterObj.size._name);
		setAttr(R20character,"size",size);

		characterObj.penalties.penalty = arrayify(characterObj.penalties.penalty);
		var ACP = importPenalties(R20character,characterObj.penalties.penalty);

		characterObj.skills.skill = arrayify(characterObj.skills.skill);
		importSkills(R20character,characterObj.skills.skill,size,ACP);
		
		if (!_.isUndefined(characterObj.senses.special))
		{
			characterObj.senses.special = arrayify(characterObj.senses.special);
			setAttr(R20character,"vision", buildShortNameList(characterObj.senses.special));
		}

		if (!_.isUndefined(characterObj.damagereduction.special))
		{
			characterObj.damagereduction.special = arrayify(characterObj.damagereduction.special);
			setAttr(R20character,"DR", buildShortNameList(characterObj.damagereduction.special));
		}

		if (!_.isUndefined(characterObj.resistances.special))
		{
			characterObj.resistances.special = arrayify(characterObj.resistances.special);
			setAttr(R20character,"resistances", buildShortNameList(characterObj.resistances.special));
		}

		if (!_.isUndefined(characterObj.immunities.special))
		{
			characterObj.immunities.special = arrayify(characterObj.immunities.special);
			setAttr(R20character,"immunities", buildShortNameList(characterObj.immunities.special));
		}

		if (!_.isUndefined(characterObj.weaknesses.special))
		{
			characterObj.weaknesses.special = arrayify(characterObj.weaknesses.special);
			setAttr(R20character,"weaknesses", buildShortNameList(characterObj.weaknesses.special));
		}
		if (!_.isUndefined(characterObj.languages.language))
		{
			characterObj.languages.language = arrayify(characterObj.languages.language);
			setAttr(R20character,"languages", buildNameList(characterObj.languages.language));
		}

		setAttr(R20character,"player-name",characterObj._playername);
		setAttr(R20character,"deity",characterObj.deity._name);
		setAttr(R20character,"race",characterObj.race._racetext.substr(0,1).toUpperCase()+characterObj.race._racetext.substr(1,1000));
		setAttr(R20character,"alignment",characterObj.alignment._name);
		setAttr(R20character,"gender",characterObj.personal._gender);
		setAttr(R20character,"age",characterObj.personal._age);
		setAttr(R20character,"height",characterObj.personal.charheight._text);
		setAttr(R20character,"weight",characterObj.personal.charweight._text);
		setAttr(R20character,"hair",characterObj.personal._hair);
		setAttr(R20character,"eyes",characterObj.personal._eyes);
		setAttr(R20character,"skin",characterObj.personal._skin);

		setAttr(R20character,"npc-cr",characterObj.challengerating._text.replace("CR ",""));
		setAttr(R20character,"npc-xp",characterObj.xpaward._value);
		
		if (!_.isUndefined(characterObj.favoredclasses.favoredclass))
		{
			characterObj.favoredclasses.favoredclass = arrayify(characterObj.favoredclasses.favoredclass);
			setAttr(R20character,"class-favored", buildNameList(characterObj.favoredclasses.favoredclass));
		}
		
		if (!_.isUndefined(characterObj.minions.character))
		{
			characterObj.minions.character = arrayify(characterObj.minions.character);
			characterObj.minions.character.forEach(function(charObj) { importCharacter(charObj,null); });
		}

		if (token !== null)
			token.set("represents",R20character.get("_id"));
			
		sendChat("HL-Import", "**"+characterObj._name + "** import complete!");
	},

    checkInstall = function() {    
        log('-=> HL-Import v'+version+' <=-  ['+(new Date(lastUpdate*1000))+']');
	},
	HandleInput = function(msg) {
		"use strict";

		var msg,
			selected,
			tok,
			characters;

		if (msg.type === "api" && msg.content.indexOf("!hl-import") !== -1 )
		{
			selected = msg.selected;
			_.each(selected, function(obj) {
				tok = getObj("graphic", obj._id);
				var JSONstring = unescape(tok.get("gmnotes")).replace(/<br>/g,"\n");
				characters = new Array(JSON.parse(JSONstring).document.public.character);
				characters.forEach(function(charObj,index) {
					if (index === 0)
						importCharacter(charObj,tok);
					else
						importCharacter(charObj,null);
				});
			});
		}
	},

	RegisterEventHandlers = function() {
		on('chat:message', HandleInput);
	};

	return {
        CheckInstall: checkInstall,
		RegisterEventHandlers: RegisterEventHandlers
	};
}());

on("ready",function(){
	'use strict';

	HLImport.CheckInstall();
	HLImport.RegisterEventHandlers();
});